/**
Lambda表达式（也称为闭包）是整个java8 发行版中最受期待的在java语言层面
上的改变，Lambda允许把函数作为一个方法的参数（函数作为参数传递进方法中） ,
或者把代码堪称数据。Lambda表达式用于简化JAVA中接口式的匿名内部类。被
称为函数式接口的概念。函数式接口就是一个具有一个方法的普通接口。像这样
的接口，可以被隐式转换为lambda表达式。

语法 （参数1，参数2...)->{...}

1.没有参数时使用Lambda表达式
2.带参数时使用Lambda表达式
3.代码块中只一句代码时使用Lambda表达式
4.代码块中有多句代码时使用Lambda表达式
5.有返回值的代码块
6.参数中使用final 关键字

//接口3个方法一个是抽象要实现的，一个是静态的（理论可以无限个），一个是默认的
interface A{
	public void method1(){}
	public default void method2(){}
	public static void method3(){}
} 
默认方法与静态方法并不影响函数式接口的契约，可以任意使用
 */

/*
package com.leo.第七章_常用类库api;



import java.util.Arrays;
import java.util.Comparator;

public class U7_L11_Lambda表达式 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//1.通过继承的方式 重写 接口的抽象方法eat
		IEat ieat=new IEatimp();
		ieat.eat();
		
		//2.直接通过接口的匿名类去 重写 抽象方法eat			
		IEat ieat_1=new IEat() {						
			public void eat() {
				System.out.println("接口匿名类");
			}
		};
		ieat_1.eat();
		
		//3.通过lambda表达式 直接推导出 抽象方法eat 并重写    省去建立class文件
		//1.没有参数时使用Lambda表达式
		IEat ieat1=()->System.out.println("无参lambda");
		ieat1.eat();
		
		//2.带参数时使用Lambda表达式
		IEat_lambda ieat2=(name,things)->{System.out.println("2.带参数时使用Lambda表达式");};
		ieat2.eat("tom", "apple");
		
		//3.代码块中只一句代码时使用Lambda表达式 无{};
		IEat_lambda ieat3=(name,things)->System.out.println("3.代码块中只一句代码时使用Lambda表达式");
		ieat3.eat("tom", "apple");
		
		//4.代码块中有多句代码时使用Lambda表达式
		IEat_lambda ieat4=(name,things)->{
			System.out.print("4.代码块中有多句代码时使用Lambda表达式");
			System.out.println(":   调用多句成功!");};
		ieat4.eat("tom", "apple");
		
		//5.有返回值的代码块
		IEat_lambda_return ieat5=(name,things)->things!=null?"thing":"10";
		String res=ieat5.eat("tom",null );
		System.out.println("5.有返回值的代码块,返回值是： "+res);
		
		//6.参数中使用final 关键字
		IEat_lambda ieat6=(final String name,final String things)->System.out.println("6.参数中使用final 关键字");
		ieat6.eat("tom", "apple");
		ieat6.method2();
		IEat_lambda.method3();
		
		//7.使用比较器 用匿名内部类的方式实现比较
		Student [] students= {new Student("aa",32)
				,new Student("bb",22)
				,new Student("cc",13)
		};
		Arrays.sort(students,new Comparator<Student>(){
			public int compare(Student o1,Student o2) {
				return o1.age-o2.age;
			};
		});
		System.out.println("7.使用比较器 用匿名内部类的方式实现比较: \n"+Arrays.toString(students));
		
		//8. 使用lambda 比较
		//Comparator<student> c=(o1,o2)->o2.age-o1.age;   这步可以省略
		Arrays.sort(students,(o1,o2)->o2.age-o1.age);
		System.out.println("8.使用lambda 比较:\n"+Arrays.toString(students));
		
	}

}

//继承和匿名
interface IEat{
	public void eat();
	public default void method2() {
		System.out.println("这是默认方法！");
	}
	public static void method3() {
		System.out.println("这是静态方法！");
	}
}

class IEatimp implements IEat{
	public void eat() {
		System.out.println("eat");
	}
}

//lambda接口
interface IEat_lambda{
	public void eat(String name,String things);
	public default void method2() {
		System.out.println("这是默认方法！");
	}
	public static void method3() {
		System.out.println("这是静态方法！");
	}
}

//lambda接口
interface IEat_lambda_return{
	public String eat(final String name,final String things);
	public default void method2() {
		System.out.println("这是默认方法！");
	}
	public static void method3() {
		System.out.println("这是静态方法！");
	}
}

class Student{
	String name;
	int age;
	public Student() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
}
*/

